home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / tcp.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  14KB  |  452 lines
  1. /*
  2.  * INET        An implementation of the TCP/IP protocol suite for the LINUX
  3.  *        operating system.  INET is implemented using the  BSD Socket
  4.  *        interface as the means of communication with the user level.
  5.  *
  6.  *        Definitions for the TCP protocol.
  7.  *
  8.  * Version:    @(#)tcp.h    1.0.2    04/28/93
  9.  *
  10.  * Author:    Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  11.  *
  12.  *        This program is free software; you can redistribute it and/or
  13.  *        modify it under the terms of the GNU General Public License
  14.  *        as published by the Free Software Foundation; either version
  15.  *        2 of the License, or (at your option) any later version.
  16.  */
  17. #ifndef _LINUX_TCP_H
  18. #define _LINUX_TCP_H
  19.  
  20. #include <linux/types.h>
  21. #include <asm/byteorder.h>
  22.  
  23. struct tcphdr {
  24.     __u16    source;
  25.     __u16    dest;
  26.     __u32    seq;
  27.     __u32    ack_seq;
  28. #if defined(__LITTLE_ENDIAN_BITFIELD)
  29.     __u16    res1:4,
  30.         doff:4,
  31.         fin:1,
  32.         syn:1,
  33.         rst:1,
  34.         psh:1,
  35.         ack:1,
  36.         urg:1,
  37.         ece:1,
  38.         cwr:1;
  39. #elif defined(__BIG_ENDIAN_BITFIELD)
  40.     __u16    doff:4,
  41.         res1:4,
  42.         cwr:1,
  43.         ece:1,
  44.         urg:1,
  45.         ack:1,
  46.         psh:1,
  47.         rst:1,
  48.         syn:1,
  49.         fin:1;
  50. #else
  51. #error    "Adjust your <asm/byteorder.h> defines"
  52. #endif    
  53.     __u16    window;
  54.     __u16    check;
  55.     __u16    urg_ptr;
  56. };
  57.  
  58.  
  59. enum {
  60.   TCP_ESTABLISHED = 1,
  61.   TCP_SYN_SENT,
  62.   TCP_SYN_RECV,
  63.   TCP_FIN_WAIT1,
  64.   TCP_FIN_WAIT2,
  65.   TCP_TIME_WAIT,
  66.   TCP_CLOSE,
  67.   TCP_CLOSE_WAIT,
  68.   TCP_LAST_ACK,
  69.   TCP_LISTEN,
  70.   TCP_CLOSING,     /* now a valid state */
  71.  
  72.   TCP_MAX_STATES /* Leave at the end! */
  73. };
  74.  
  75. #define TCP_STATE_MASK    0xF
  76. #define TCP_ACTION_FIN    (1 << 7)
  77.  
  78. enum {
  79.   TCPF_ESTABLISHED = (1 << 1),
  80.   TCPF_SYN_SENT  = (1 << 2),
  81.   TCPF_SYN_RECV  = (1 << 3),
  82.   TCPF_FIN_WAIT1 = (1 << 4),
  83.   TCPF_FIN_WAIT2 = (1 << 5),
  84.   TCPF_TIME_WAIT = (1 << 6),
  85.   TCPF_CLOSE     = (1 << 7),
  86.   TCPF_CLOSE_WAIT = (1 << 8),
  87.   TCPF_LAST_ACK  = (1 << 9),
  88.   TCPF_LISTEN    = (1 << 10),
  89.   TCPF_CLOSING   = (1 << 11) 
  90. };
  91.  
  92. /*
  93.  *    The union cast uses a gcc extension to avoid aliasing problems
  94.  *  (union is compatible to any of its members)
  95.  *  This means this part of the code is -fstrict-aliasing safe now.
  96.  */
  97. union tcp_word_hdr { 
  98.     struct tcphdr hdr;
  99.     __u32           words[5];
  100. }; 
  101.  
  102. #define tcp_flag_word(tp) ( ((union tcp_word_hdr *)(tp))->words [3]) 
  103.  
  104. enum { 
  105.     TCP_FLAG_CWR = __constant_htonl(0x00800000), 
  106.     TCP_FLAG_ECE = __constant_htonl(0x00400000), 
  107.     TCP_FLAG_URG = __constant_htonl(0x00200000), 
  108.     TCP_FLAG_ACK = __constant_htonl(0x00100000), 
  109.     TCP_FLAG_PSH = __constant_htonl(0x00080000), 
  110.     TCP_FLAG_RST = __constant_htonl(0x00040000), 
  111.     TCP_FLAG_SYN = __constant_htonl(0x00020000), 
  112.     TCP_FLAG_FIN = __constant_htonl(0x00010000),
  113.     TCP_RESERVED_BITS = __constant_htonl(0x0F000000),
  114.     TCP_DATA_OFFSET = __constant_htonl(0xF0000000)
  115. }; 
  116.  
  117. /* TCP socket options */
  118. #define TCP_NODELAY        1    /* Turn off Nagle's algorithm. */
  119. #define TCP_MAXSEG        2    /* Limit MSS */
  120. #define TCP_CORK        3    /* Never send partially complete segments */
  121. #define TCP_KEEPIDLE        4    /* Start keeplives after this period */
  122. #define TCP_KEEPINTVL        5    /* Interval between keepalives */
  123. #define TCP_KEEPCNT        6    /* Number of keepalives before death */
  124. #define TCP_SYNCNT        7    /* Number of SYN retransmits */
  125. #define TCP_LINGER2        8    /* Life time of orphaned FIN-WAIT-2 state */
  126. #define TCP_DEFER_ACCEPT    9    /* Wake up listener only when data arrive */
  127. #define TCP_WINDOW_CLAMP    10    /* Bound advertised window */
  128. #define TCP_INFO        11    /* Information about this connection. */
  129. #define TCP_QUICKACK        12    /* Block/reenable quick acks */
  130.  
  131. #define TCPI_OPT_TIMESTAMPS    1
  132. #define TCPI_OPT_SACK        2
  133. #define TCPI_OPT_WSCALE        4
  134. #define TCPI_OPT_ECN        8
  135.  
  136. enum tcp_ca_state
  137. {
  138.     TCP_CA_Open = 0,
  139. #define TCPF_CA_Open    (1<<TCP_CA_Open)
  140.     TCP_CA_Disorder = 1,
  141. #define TCPF_CA_Disorder (1<<TCP_CA_Disorder)
  142.     TCP_CA_CWR = 2,
  143. #define TCPF_CA_CWR    (1<<TCP_CA_CWR)
  144.     TCP_CA_Recovery = 3,
  145. #define TCPF_CA_Recovery (1<<TCP_CA_Recovery)
  146.     TCP_CA_Loss = 4
  147. #define TCPF_CA_Loss    (1<<TCP_CA_Loss)
  148. };
  149.  
  150. struct tcp_info
  151. {
  152.     __u8    tcpi_state;
  153.     __u8    tcpi_ca_state;
  154.     __u8    tcpi_retransmits;
  155.     __u8    tcpi_probes;
  156.     __u8    tcpi_backoff;
  157.     __u8    tcpi_options;
  158.     __u8    tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
  159.  
  160.     __u32    tcpi_rto;
  161.     __u32    tcpi_ato;
  162.     __u32    tcpi_snd_mss;
  163.     __u32    tcpi_rcv_mss;
  164.  
  165.     __u32    tcpi_unacked;
  166.     __u32    tcpi_sacked;
  167.     __u32    tcpi_lost;
  168.     __u32    tcpi_retrans;
  169.     __u32    tcpi_fackets;
  170.  
  171.     /* Times. */
  172.     __u32    tcpi_last_data_sent;
  173.     __u32    tcpi_last_ack_sent;     /* Not remembered, sorry. */
  174.     __u32    tcpi_last_data_recv;
  175.     __u32    tcpi_last_ack_recv;
  176.  
  177.     /* Metrics. */
  178.     __u32    tcpi_pmtu;
  179.     __u32    tcpi_rcv_ssthresh;
  180.     __u32    tcpi_rtt;
  181.     __u32    tcpi_rttvar;
  182.     __u32    tcpi_snd_ssthresh;
  183.     __u32    tcpi_snd_cwnd;
  184.     __u32    tcpi_advmss;
  185.     __u32    tcpi_reordering;
  186.  
  187.     __u32    tcpi_rcv_rtt;
  188.     __u32    tcpi_rcv_space;
  189.  
  190.     __u32    tcpi_total_retrans;
  191. };
  192.  
  193. #ifdef __KERNEL__
  194.  
  195. #include <linux/config.h>
  196. #include <linux/skbuff.h>
  197. #include <linux/ip.h>
  198. #include <net/sock.h>
  199.  
  200. /* This defines a selective acknowledgement block. */
  201. struct tcp_sack_block {
  202.     __u32    start_seq;
  203.     __u32    end_seq;
  204. };
  205.  
  206. enum tcp_congestion_algo {
  207.     TCP_RENO=0,
  208.     TCP_VEGAS,
  209.     TCP_WESTWOOD,
  210.     TCP_BIC,
  211. };
  212.  
  213. struct tcp_options_received {
  214. /*    PAWS/RTTM data    */
  215.     long    ts_recent_stamp;/* Time we stored ts_recent (for aging) */
  216.     __u32    ts_recent;    /* Time stamp to echo next        */
  217.     __u32    rcv_tsval;    /* Time stamp value                 */
  218.     __u32    rcv_tsecr;    /* Time stamp echo reply            */
  219.     char    saw_tstamp;    /* Saw TIMESTAMP on last packet        */
  220.     char    tstamp_ok;    /* TIMESTAMP seen on SYN packet        */
  221.     char    sack_ok;    /* SACK seen on SYN packet        */
  222.     char    wscale_ok;    /* Wscale seen on SYN packet        */
  223.     __u8    snd_wscale;    /* Window scaling received from sender    */
  224.     __u8    rcv_wscale;    /* Window scaling to send to receiver    */
  225. /*    SACKs data    */
  226.     __u8    dsack;        /* D-SACK is scheduled            */
  227.     __u8    eff_sacks;    /* Size of SACK array to send with next packet */
  228.     __u8    num_sacks;    /* Number of SACK blocks        */
  229.     __u8    __pad;
  230.     __u16    user_mss;      /* mss requested by user in ioctl */
  231.     __u16    mss_clamp;    /* Maximal mss, negotiated at connection setup */
  232. };
  233.  
  234. struct tcp_sock {
  235.     /* inet_sock has to be the first member of tcp_sock */
  236.     struct inet_sock    inet;
  237.     int    tcp_header_len;    /* Bytes of tcp header to send        */
  238.  
  239. /*
  240.  *    Header prediction flags
  241.  *    0x5?10 << 16 + snd_wnd in net byte order
  242.  */
  243.     __u32    pred_flags;
  244.  
  245. /*
  246.  *    RFC793 variables by their proper names. This means you can
  247.  *    read the code and the spec side by side (and laugh ...)
  248.  *    See RFC793 and RFC1122. The RFC writes these in capitals.
  249.  */
  250.      __u32    rcv_nxt;    /* What we want to receive next     */
  251.      __u32    snd_nxt;    /* Next sequence we send        */
  252.  
  253.      __u32    snd_una;    /* First byte we want an ack for    */
  254.      __u32    snd_sml;    /* Last byte of the most recently transmitted small packet */
  255.     __u32    rcv_tstamp;    /* timestamp of last received ACK (for keepalives) */
  256.     __u32    lsndtime;    /* timestamp of last sent data packet (for restart window) */
  257.     struct tcp_bind_bucket *bind_hash;
  258.     /* Delayed ACK control data */
  259.     struct {
  260.         __u8    pending;    /* ACK is pending */
  261.         __u8    quick;        /* Scheduled number of quick acks    */
  262.         __u8    pingpong;    /* The session is interactive        */
  263.         __u8    blocked;    /* Delayed ACK was blocked by socket lock*/
  264.         __u32    ato;        /* Predicted tick of soft clock        */
  265.         unsigned long timeout;    /* Currently scheduled timeout        */
  266.         __u32    lrcvtime;    /* timestamp of last received data packet*/
  267.         __u16    last_seg_size;    /* Size of last incoming segment    */
  268.         __u16    rcv_mss;    /* MSS used for delayed ACK decisions    */ 
  269.     } ack;
  270.  
  271.     /* Data for direct copy to user */
  272.     struct {
  273.         struct sk_buff_head    prequeue;
  274.         struct task_struct    *task;
  275.         struct iovec        *iov;
  276.         int            memory;
  277.         int            len;
  278.     } ucopy;
  279.  
  280.     __u32    snd_wl1;    /* Sequence for window update        */
  281.     __u32    snd_wnd;    /* The window we expect to receive    */
  282.     __u32    max_window;    /* Maximal window ever seen from peer    */
  283.     __u32    pmtu_cookie;    /* Last pmtu seen by socket        */
  284.     __u32    mss_cache;    /* Cached effective mss, not including SACKS */
  285.     __u16    mss_cache_std;    /* Like mss_cache, but without TSO */
  286.     __u16    ext_header_len;    /* Network protocol overhead (IP/IPv6 options) */
  287.     __u16    ext2_header_len;/* Options depending on route */
  288.     __u8    ca_state;    /* State of fast-retransmit machine     */
  289.     __u8    retransmits;    /* Number of unrecovered RTO timeouts.    */
  290.  
  291.     __u32    frto_highmark;    /* snd_nxt when RTO occurred */
  292.     __u8    reordering;    /* Packet reordering metric.        */
  293.     __u8    frto_counter;    /* Number of new acks after RTO */
  294.  
  295.     __u8    adv_cong;    /* Using Vegas, Westwood, or BIC */
  296.     __u8    defer_accept;    /* User waits for some data after accept() */
  297.  
  298. /* RTT measurement */
  299.     __u32    srtt;        /* smoothed round trip time << 3    */
  300.     __u32    mdev;        /* medium deviation            */
  301.     __u32    mdev_max;    /* maximal mdev for the last rtt period    */
  302.     __u32    rttvar;        /* smoothed mdev_max            */
  303.     __u32    rtt_seq;    /* sequence number to update rttvar    */
  304.     __u32    rto;        /* retransmit timeout            */
  305.  
  306.     __u32    packets_out;    /* Packets which are "in flight"    */
  307.     __u32    left_out;    /* Packets which leaved network    */
  308.     __u32    retrans_out;    /* Retransmitted packets out        */
  309.     __u8    backoff;    /* backoff                */
  310. /*
  311.  *      Options received (usually on last packet, some only on SYN packets).
  312.  */
  313.     __u8    nonagle;    /* Disable Nagle algorithm?             */
  314.     __u8    keepalive_probes; /* num of allowed keep alive probes    */
  315.  
  316.     __u8    probes_out;    /* unanswered 0 window probes        */
  317.     struct tcp_options_received rx_opt;
  318.  
  319. /*
  320.  *    Slow start and congestion control (see also Nagle, and Karn & Partridge)
  321.  */
  322.      __u32    snd_ssthresh;    /* Slow start size threshold        */
  323.      __u32    snd_cwnd;    /* Sending congestion window        */
  324.      __u16    snd_cwnd_cnt;    /* Linear increase counter        */
  325.     __u16    snd_cwnd_clamp; /* Do not allow snd_cwnd to grow above this */
  326.     __u32    snd_cwnd_used;
  327.     __u32    snd_cwnd_stamp;
  328.  
  329.     /* Two commonly used timers in both sender and receiver paths. */
  330.     unsigned long        timeout;
  331.      struct timer_list    retransmit_timer;    /* Resend (no ack)    */
  332.      struct timer_list    delack_timer;        /* Ack delay         */
  333.  
  334.     struct sk_buff_head    out_of_order_queue; /* Out of order segments go here */
  335.  
  336.     struct tcp_func        *af_specific;    /* Operations which are AF_INET{4,6} specific    */
  337.  
  338.      __u32    rcv_wnd;    /* Current receiver window        */
  339.     __u32    rcv_wup;    /* rcv_nxt on last window update sent    */
  340.     __u32    write_seq;    /* Tail(+1) of data held in tcp send buffer */
  341.     __u32    pushed_seq;    /* Last pushed seq, required to talk to windows */
  342.     __u32    copied_seq;    /* Head of yet unread data        */
  343.  
  344. /*    SACKs data    */
  345.     struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */
  346.     struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/
  347.  
  348.     __u32    window_clamp;    /* Maximal window to advertise        */
  349.     __u32    rcv_ssthresh;    /* Current window clamp            */
  350.     __u16    advmss;        /* Advertised MSS            */
  351.  
  352.     __u8    syn_retries;    /* num of allowed syn retries */
  353.     __u8    ecn_flags;    /* ECN status bits.            */
  354.     __u16    prior_ssthresh; /* ssthresh saved at recovery start    */
  355.     __u16    __pad1;
  356.     __u32    lost_out;    /* Lost packets            */
  357.     __u32    sacked_out;    /* SACK'd packets            */
  358.     __u32    fackets_out;    /* FACK'd packets            */
  359.     __u32    high_seq;    /* snd_nxt at onset of congestion    */
  360.  
  361.     __u32    retrans_stamp;    /* Timestamp of the last retransmit,
  362.                  * also used in SYN-SENT to remember stamp of
  363.                  * the first SYN. */
  364.     __u32    undo_marker;    /* tracking retrans started here. */
  365.     int    undo_retrans;    /* number of undoable retransmissions. */
  366.     __u32    urg_seq;    /* Seq of received urgent pointer */
  367.     __u16    urg_data;    /* Saved octet of OOB data and control flags */
  368.     __u8    pending;    /* Scheduled timer event    */
  369.     __u8    urg_mode;    /* In urgent mode        */
  370.     __u32    snd_up;        /* Urgent pointer        */
  371.  
  372.     __u32    total_retrans;    /* Total retransmits for entire connection */
  373.  
  374.     /* The syn_wait_lock is necessary only to avoid proc interface having
  375.      * to grab the main lock sock while browsing the listening hash
  376.      * (otherwise it's deadlock prone).
  377.      * This lock is acquired in read mode only from listening_get_next()
  378.      * and it's acquired in write mode _only_ from code that is actively
  379.      * changing the syn_wait_queue. All readers that are holding
  380.      * the master sock lock don't need to grab this lock in read mode
  381.      * too as the syn_wait_queue writes are always protected from
  382.      * the main sock lock.
  383.      */
  384.     rwlock_t        syn_wait_lock;
  385.     struct tcp_listen_opt    *listen_opt;
  386.  
  387.     /* FIFO of established children */
  388.     struct open_request    *accept_queue;
  389.     struct open_request    *accept_queue_tail;
  390.  
  391.     unsigned int        keepalive_time;      /* time before keep alive takes place */
  392.     unsigned int        keepalive_intvl;  /* time interval between keep alive probes */
  393.     int            linger2;
  394.  
  395.     unsigned long last_synq_overflow; 
  396.  
  397. /* Receiver side RTT estimation */
  398.     struct {
  399.         __u32    rtt;
  400.         __u32    seq;
  401.         __u32    time;
  402.     } rcv_rtt_est;
  403.  
  404. /* Receiver queue space */
  405.     struct {
  406.         int    space;
  407.         __u32    seq;
  408.         __u32    time;
  409.     } rcvq_space;
  410.  
  411. /* TCP Westwood structure */
  412.         struct {
  413.                 __u32    bw_ns_est;        /* first bandwidth estimation..not too smoothed 8) */
  414.                 __u32    bw_est;           /* bandwidth estimate */
  415.                 __u32    rtt_win_sx;       /* here starts a new evaluation... */
  416.                 __u32    bk;
  417.                 __u32    snd_una;          /* used for evaluating the number of acked bytes */
  418.                 __u32    cumul_ack;
  419.                 __u32    accounted;
  420.                 __u32    rtt;
  421.                 __u32    rtt_min;          /* minimum observed RTT */
  422.         } westwood;
  423.  
  424. /* Vegas variables */
  425.     struct {
  426.         __u32    beg_snd_nxt;    /* right edge during last RTT */
  427.         __u32    beg_snd_una;    /* left edge  during last RTT */
  428.         __u32    beg_snd_cwnd;    /* saves the size of the cwnd */
  429.         __u8    doing_vegas_now;/* if true, do vegas for this RTT */
  430.         __u16    cntRTT;        /* # of RTTs measured within last RTT */
  431.         __u32    minRTT;        /* min of RTTs measured within last RTT (in usec) */
  432.         __u32    baseRTT;    /* the min of all Vegas RTT measurements seen (in usec) */
  433.     } vegas;
  434.  
  435.     /* BI TCP Parameters */
  436.     struct {
  437.         __u32    cnt;        /* increase cwnd by 1 after this number of ACKs */
  438.         __u32     last_max_cwnd;    /* last maximium snd_cwnd */
  439.         __u32    last_cwnd;    /* the last snd_cwnd */
  440.         __u32   last_stamp;     /* time when updated last_cwnd */
  441.     } bictcp;
  442. };
  443.  
  444. static inline struct tcp_sock *tcp_sk(const struct sock *sk)
  445. {
  446.     return (struct tcp_sock *)sk;
  447. }
  448.  
  449. #endif
  450.  
  451. #endif    /* _LINUX_TCP_H */
  452.